package com.mybase.app.advancedBase.secret;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;
import com.mybase.app.Utils.cryptogram;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;

/**
 * Created by tukela on 2015/3/12.
 */
public class SecretActivity extends Activity {
    public static String encrypt(String seed, String cleartext) throws Exception {
        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] result = encrypt(rawKey, cleartext.getBytes());
        return toHex(result);
    }

    public static String decrypt(String seed, String encrypted) throws Exception {
        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] enc = toByte(encrypted);
        byte[] result = decrypt(rawKey, enc);
        return new String(result);
    }

    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
        sr.setSeed(seed);
        kgen.init(128, sr); // 192 and 256 bits may not be available
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }


    private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }

    private static byte[] decrypt(byte[] raw, byte[] encrypted) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }

    public static String toHex(String txt) {
        return toHex(txt.getBytes());
    }
    public static String fromHex(String hex) {
        return new String(toByte(hex));
    }

    public static byte[] toByte(String hexString) {
        int len = hexString.length()/2;
        byte[] result = new byte[len];
        for (int i = 0; i < len; i++)
            result[i] = Integer.valueOf(hexString.substring(2*i, 2*i+2), 16).byteValue();
        return result;
    }

    public static String toHex(byte[] buf) {
        if (buf == null)
            return "";
        StringBuffer result = new StringBuffer(2*buf.length);
        for (int i = 0; i < buf.length; i++) {
            appendHex(result, buf[i]);
        }
        return result.toString();
    }
    private final static String HEX = "0123456789ABCDEF";
    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b>>4)&0x0f)).append(HEX.charAt(b&0x0f));
    }
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        String encryptingCode="";
        String decryptingCode="";
        String masterPassword = "a";
        String originalText = "01复古风格发给";
        byte[] text = new byte[]{'0','1','2','3','4','5','6','7','8','9'};
        byte[] password = new byte[]{'a'};

        try {
            encryptingCode = SecretActivity.encrypt(masterPassword,originalText);
//          System.out.println("加密结果为 " + encryptingCode);
            Log.i("加密结果为 ", encryptingCode);
            decryptingCode = SecretActivity.decrypt(masterPassword, encryptingCode);
            System.out.println("解密结果为 " + decryptingCode);
            Log.i("解密结果",decryptingCode);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        TextView textView=new TextView(this);
       // textView.setText("加密结果为: "+encryptingCode+"|"+"解密结果为: " + decryptingCode);
       // textView.setText(SecretUtil.Test2());
        textView.setText(cryptogram.Test());
        setContentView(textView);
    }

}
















    /**
     * 加密
     *
     * @param content 需要加密的内容
     * @param password  加密密码
     * @return
     */
//    public static byte[] encrypt(String content, String password) {
//        try {
//            KeyGenerator kgen = KeyGenerator.getInstance("AES");
//            kgen.init(128, new SecureRandom(password.getBytes()));
//            SecretKey secretKey = kgen.generateKey();
//            byte[] enCodeFormat = secretKey.getEncoded();
//            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
//            Cipher cipher = Cipher.getInstance("AES");// 创建密码器
//            byte[] byteContent = content.getBytes("utf-8");
//            cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
//            byte[] result = cipher.doFinal(byteContent);
//            return result; // 加密
//        } catch (NoSuchAlgorithmException e) {
//            e.printStackTrace();
//        } catch (NoSuchPaddingException e) {
//            e.printStackTrace();
//        } catch (InvalidKeyException e) {
//            e.printStackTrace();
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//        } catch (IllegalBlockSizeException e) {
//            e.printStackTrace();
//        } catch (BadPaddingException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//2.2 解密
//
//        代码有详细注释，不多废话
//        注意：解密的时候要传入byte数组
//
//
//
///**解密
// * @param content  待解密内容
// * @param password 解密密钥
// * @return
// */
//public static byte[] decrypt(byte[] content, String password) {
//        try {
//        KeyGenerator kgen = KeyGenerator.getInstance("AES");
//        kgen.init(128, new SecureRandom(password.getBytes()));
//        SecretKey secretKey = kgen.generateKey();
//        byte[] enCodeFormat = secretKey.getEncoded();
//        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
//        Cipher cipher = Cipher.getInstance("AES");// 创建密码器
//        cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
//        byte[] result = cipher.doFinal(content);
//        return result; // 加密
//        } catch (NoSuchAlgorithmException e) {
//        e.printStackTrace();
//        } catch (NoSuchPaddingException e) {
//        e.printStackTrace();
//        } catch (InvalidKeyException e) {
//        e.printStackTrace();
//        } catch (IllegalBlockSizeException e) {
//        e.printStackTrace();
//        } catch (BadPaddingException e) {
//        e.printStackTrace();
//        }
//        return null;
//        }
//
//        2.3 测试代码
//
//
//
//
//        String content = "test";
//        String password = "12345678";
////加密
//        System.out.println("加密前：" + content);
//        byte[] encryptResult = encrypt(content, password);
////解密
//        byte[] decryptResult = decrypt(encryptResult,password);
//        System.out.println("解密后：" + new String(decryptResult));
//
//        输出结果如下：
//        加密前：test
//        解密后：test
//        2.4 容易出错的地方
//
//        但是如果我们将测试代码修改一下，如下：
//
//
//
//        String content = "test";
//        String password = "12345678";
////加密
//        System.out.println("加密前：" + content);
//        byte[] encryptResult = encrypt(content, password);
//        try {
//        String encryptResultStr = new String(encryptResult,"utf-8");
//        //解密
//        byte[] decryptResult = decrypt(encryptResultStr.getBytes("utf-8"),password);
//        System.out.println("解密后：" + new String(decryptResult));
//        } catch (UnsupportedEncodingException e) {
//        e.printStackTrace();
//        }
//
//        则，系统会报出如下异常：
//        javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher
//        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
//        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
//        at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA13*..)
//        at javax.crypto.Cipher.doFinal(DashoA13*..)
//        这主要是因为加密后的byte数组是不能强制转换成字符串的，换言之：字符串和byte数组在这种情况下不是互逆的；要避免这种情况，我们需要做一些修订，可以考虑将二进制数据转换成十六进制表示，主要有如下两个方法：
//        2.4.1将二进制转换成16进制
//
//
//
//
///**将二进制转换成16进制
// * @param buf
// * @return
// */
//public static String parseByte2HexStr(byte buf[]) {
//        StringBuffer sb = new StringBuffer();
//        for (int i = 0; i < buf.length; i++) {
//        String hex = Integer.toHexString(buf[i] & 0xFF);
//        if (hex.length() == 1) {
//        hex = '0' + hex;
//        }
//        sb.append(hex.toUpperCase());
//        }
//        return sb.toString();
//        }
//
//        2.4.2 将16进制转换为二进制
//
//
//
//
///**将16进制转换为二进制
// * @param hexStr
// * @return
// */
//public static byte[] parseHexStr2Byte(String hexStr) {
//        if (hexStr.length() < 1)
//        return null;
//        byte[] result = new byte[hexStr.length()/2];
//        for (int i = 0;i< hexStr.length()/2; i++) {
//        int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
//        int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
//        result[i] = (byte) (high * 16 + low);
//        }
//        return result;
//        }
//
//        然后，我们再修订以上测试代码，如下：
//
//
//
//        String content = "test";
//        String password = "12345678";
////加密
//        System.out.println("加密前：" + content);
//        byte[] encryptResult = encrypt(content, password);
//        String encryptResultStr = parseByte2HexStr(encryptResult);
//        System.out.println("加密后：" + encryptResultStr);
////解密
//        byte[] decryptFrom = parseHexStr2Byte(encryptResultStr);
//        byte[] decryptResult = decrypt(decryptFrom,password);
//        System.out.println("解密后：" + new String(decryptResult));
//
//        测试结果如下：
//        加密前：test
//        加密后：73C58BAFE578C59366D8C995CD0B9D6D
//        解密后：test